Termination w.r.t. Q proof of TRS/currying/AG01#3.57.trs

Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

APP'(app'(minus, app'(s, x)), app'(s, y)) → APP'(app'(minus, x), y)
APP'(app'(app'(app'(filter2, false), f), x), xs) → APP'(filter, f)
APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(app'(map, f), xs)
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(plus, x)
APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(quot, app'(app'(minus, x), y))
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(f, x)
APP'(app'(plus, app'(s, x)), y) → APP'(app'(plus, x), y)
APP'(app'(plus, app'(s, x)), y) → APP'(s, app'(app'(plus, x), y))
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(app'(app'(filter2, app'(f, x)), f), x)
APP'(app'(plus, app'(s, x)), y) → APP'(plus, x)
APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(minus, x)
APP'(app'(minus, app'(app'(minus, x), y)), z) → APP'(app'(plus, y), z)
APP'(app'(app'(app'(filter2, true), f), x), xs) → APP'(app'(filter, f), xs)
APP'(app'(minus, app'(app'(minus, x), y)), z) → APP'(plus, y)
APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(app'(cons, app'(app'(plus, x), y)), l)
APP'(app'(minus, app'(s, x)), app'(s, y)) → APP'(minus, x)
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(cons, app'(app'(plus, x), y))
APP'(app'(app'(app'(filter2, true), f), x), xs) → APP'(app'(cons, x), app'(app'(filter, f), xs))
APP'(app'(app, app'(app'(cons, x), l)), k) → APP'(app, l)
APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(app'(minus, x), y)
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
APP'(app'(app'(app'(filter2, true), f), x), xs) → APP'(cons, x)
APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(f, x)
APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(app'(quot, app'(app'(minus, x), y)), app'(s, y))
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(app'(plus, x), y)
APP'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → APP'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
APP'(app'(app, app'(app'(cons, x), l)), k) → APP'(app'(cons, x), app'(app'(app, l), k))
APP'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → APP'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k))))
APP'(app'(app'(app'(filter2, false), f), x), xs) → APP'(app'(filter, f), xs)
APP'(app'(app'(app'(filter2, true), f), x), xs) → APP'(filter, f)
APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(cons, app'(f, x))
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(filter2, app'(f, x))
APP'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → APP'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(app'(filter2, app'(f, x)), f)
APP'(app'(minus, app'(app'(minus, x), y)), z) → APP'(app'(minus, x), app'(app'(plus, y), z))
APP'(app'(app, app'(app'(cons, x), l)), k) → APP'(app'(app, l), k)

The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

Q DP problem:
The TRS P consists of the following rules:

APP'(app'(minus, app'(s, x)), app'(s, y)) → APP'(app'(minus, x), y)
APP'(app'(app'(app'(filter2, false), f), x), xs) → APP'(filter, f)
APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(app'(map, f), xs)
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(plus, x)
APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(quot, app'(app'(minus, x), y))
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(f, x)
APP'(app'(plus, app'(s, x)), y) → APP'(app'(plus, x), y)
APP'(app'(plus, app'(s, x)), y) → APP'(s, app'(app'(plus, x), y))
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(app'(app'(filter2, app'(f, x)), f), x)
APP'(app'(plus, app'(s, x)), y) → APP'(plus, x)
APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(minus, x)
APP'(app'(minus, app'(app'(minus, x), y)), z) → APP'(app'(plus, y), z)
APP'(app'(app'(app'(filter2, true), f), x), xs) → APP'(app'(filter, f), xs)
APP'(app'(minus, app'(app'(minus, x), y)), z) → APP'(plus, y)
APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(app'(cons, app'(app'(plus, x), y)), l)
APP'(app'(minus, app'(s, x)), app'(s, y)) → APP'(minus, x)
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(cons, app'(app'(plus, x), y))
APP'(app'(app'(app'(filter2, true), f), x), xs) → APP'(app'(cons, x), app'(app'(filter, f), xs))
APP'(app'(app, app'(app'(cons, x), l)), k) → APP'(app, l)
APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(app'(minus, x), y)
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
APP'(app'(app'(app'(filter2, true), f), x), xs) → APP'(cons, x)
APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(f, x)
APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(app'(quot, app'(app'(minus, x), y)), app'(s, y))
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(app'(plus, x), y)
APP'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → APP'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
APP'(app'(app, app'(app'(cons, x), l)), k) → APP'(app'(cons, x), app'(app'(app, l), k))
APP'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → APP'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k))))
APP'(app'(app'(app'(filter2, false), f), x), xs) → APP'(app'(filter, f), xs)
APP'(app'(app'(app'(filter2, true), f), x), xs) → APP'(filter, f)
APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(cons, app'(f, x))
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(filter2, app'(f, x))
APP'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → APP'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(app'(filter2, app'(f, x)), f)
APP'(app'(minus, app'(app'(minus, x), y)), z) → APP'(app'(minus, x), app'(app'(plus, y), z))
APP'(app'(app, app'(app'(cons, x), l)), k) → APP'(app'(app, l), k)

The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We deleted some edges using various graph approximations

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

        ↳ QDP

          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

APP'(app'(minus, app'(s, x)), app'(s, y)) → APP'(app'(minus, x), y)
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(plus, x)
APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(app'(map, f), xs)
APP'(app'(app'(app'(filter2, false), f), x), xs) → APP'(filter, f)
APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(quot, app'(app'(minus, x), y))
APP'(app'(plus, app'(s, x)), y) → APP'(app'(plus, x), y)
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(f, x)
APP'(app'(plus, app'(s, x)), y) → APP'(s, app'(app'(plus, x), y))
APP'(app'(plus, app'(s, x)), y) → APP'(plus, x)
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(app'(app'(filter2, app'(f, x)), f), x)
APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(minus, x)
APP'(app'(minus, app'(app'(minus, x), y)), z) → APP'(app'(plus, y), z)
APP'(app'(app'(app'(filter2, true), f), x), xs) → APP'(app'(filter, f), xs)
APP'(app'(minus, app'(app'(minus, x), y)), z) → APP'(plus, y)
APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(app'(cons, app'(app'(plus, x), y)), l)
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(cons, app'(app'(plus, x), y))
APP'(app'(minus, app'(s, x)), app'(s, y)) → APP'(minus, x)
APP'(app'(app, app'(app'(cons, x), l)), k) → APP'(app, l)
APP'(app'(app'(app'(filter2, true), f), x), xs) → APP'(app'(cons, x), app'(app'(filter, f), xs))
APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(app'(minus, x), y)
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(f, x)
APP'(app'(app'(app'(filter2, true), f), x), xs) → APP'(cons, x)
APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(app'(quot, app'(app'(minus, x), y)), app'(s, y))
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(app'(plus, x), y)
APP'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → APP'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
APP'(app'(app, app'(app'(cons, x), l)), k) → APP'(app'(cons, x), app'(app'(app, l), k))
APP'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → APP'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k))))
APP'(app'(app'(app'(filter2, false), f), x), xs) → APP'(app'(filter, f), xs)
APP'(app'(app'(app'(filter2, true), f), x), xs) → APP'(filter, f)
APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(cons, app'(f, x))
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(filter2, app'(f, x))
APP'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → APP'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(app'(filter2, app'(f, x)), f)
APP'(app'(minus, app'(app'(minus, x), y)), z) → APP'(app'(minus, x), app'(app'(plus, y), z))
APP'(app'(app, app'(app'(cons, x), l)), k) → APP'(app'(app, l), k)

The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 7 SCCs with 26 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ QDPOrderProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APP'(app'(app, app'(app'(cons, x), l)), k) → APP'(app'(app, l), k)

The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13]. Here, we combined the reduction pair processor with the A-transformation [14] which results in the following intermediate Q-DP Problem.
Q DP problem:
The TRS P consists of the following rules:

APP(cons(x, l), k) → APP(l, k)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.

The following pairs can be oriented strictly and are deleted.

APP'(app'(app, app'(app'(cons, x), l)), k) → APP'(app'(app, l), k)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
APP(x1, x2) = APP(x1, x2)
cons(x1, x2) = cons(x1, x2)

Recursive path order with status [2].
Quasi-Precedence:

trivial

Status:

APP₂: multiset
cons₂: multiset

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APP'(app'(plus, app'(s, x)), y) → APP'(app'(plus, x), y)

The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

PLUS(s(x), y) → PLUS(x, y)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.

The following pairs can be oriented strictly and are deleted.

APP'(app'(plus, app'(s, x)), y) → APP'(app'(plus, x), y)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
PLUS(x1, x2) = PLUS(x1, x2)
s(x1) = s(x1)

Recursive path order with status [2].
Quasi-Precedence:

[PLUS₂, s_1]

Status:

s₁: multiset
PLUS₂: multiset

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))

The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

SUM(cons(x, cons(y, l))) → SUM(cons(plus(x, y), l))

The TRS R consists of the following rules:

plus(0, y) → y
plus(s(x), y) → s(plus(x, y))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

The following pairs can be oriented strictly and are deleted.

APP'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → APP'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))

The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
SUM(x1) = SUM(x1)
cons(x1, x2) = cons(x1, x2)
plus(x1, x2) = plus(x2)
s(x1) = x1
0 = 0

Recursive path order with status [2].
Quasi-Precedence:

0 > [SUM₁, cons₂, plus_1]

Status:

SUM₁: multiset
plus₁: [1]
0: multiset
cons₂: [2,1]

The following usable rules [14] were oriented:

app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(plus, 0), y) → y

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APP'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → APP'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))

The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APP'(app'(minus, app'(s, x)), app'(s, y)) → APP'(app'(minus, x), y)
APP'(app'(minus, app'(app'(minus, x), y)), z) → APP'(app'(minus, x), app'(app'(plus, y), z))

The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

MINUS(minus(x, y), z) → MINUS(x, plus(y, z))
MINUS(s(x), s(y)) → MINUS(x, y)

The TRS R consists of the following rules:

plus(0, y) → y
plus(s(x), y) → s(plus(x, y))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

The following pairs can be oriented strictly and are deleted.

APP'(app'(minus, app'(app'(minus, x), y)), z) → APP'(app'(minus, x), app'(app'(plus, y), z))

The remaining pairs can at least be oriented weakly.

APP'(app'(minus, app'(s, x)), app'(s, y)) → APP'(app'(minus, x), y)

Used ordering: Combined order from the following AFS and order.
MINUS(x1, x2) = MINUS(x1, x2)
minus(x1, x2) = minus(x1)
plus(x1, x2) = x2
s(x1) = x1
0 = 0

Recursive path order with status [2].
Quasi-Precedence:

minus₁ > MINUS₂

Status:

minus₁: [1]
0: multiset
MINUS₂: [2,1]

The following usable rules [14] were oriented:

app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(plus, 0), y) → y

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APP'(app'(minus, app'(s, x)), app'(s, y)) → APP'(app'(minus, x), y)

The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

MINUS(s(x), s(y)) → MINUS(x, y)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.

The following pairs can be oriented strictly and are deleted.

APP'(app'(minus, app'(s, x)), app'(s, y)) → APP'(app'(minus, x), y)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
MINUS(x1, x2) = MINUS(x1)
s(x1) = s(x1)

Recursive path order with status [2].
Quasi-Precedence:

[MINUS₁, s_1]

Status:

MINUS₁: multiset
s₁: multiset

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

              ↳ QDP

              ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(app'(quot, app'(app'(minus, x), y)), app'(s, y))

The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

QUOT(s(x), s(y)) → QUOT(minus(x, y), s(y))

The TRS R consists of the following rules:

minus(x, 0) → x
minus(minus(x, y), z) → minus(x, plus(y, z))
minus(s(x), s(y)) → minus(x, y)
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

The following pairs can be oriented strictly and are deleted.

APP'(app'(quot, app'(s, x)), app'(s, y)) → APP'(app'(quot, app'(app'(minus, x), y)), app'(s, y))

The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
QUOT(x1, x2) = QUOT(x1, x2)
s(x1) = s(x1)
minus(x1, x2) = x1
plus(x1, x2) = plus
0 = 0

Recursive path order with status [2].
Quasi-Precedence:

[QUOT₂, s_1] > plus

Status:

QUOT₂: multiset
plus: multiset
0: multiset
s₁: multiset

The following usable rules [14] were oriented:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

              ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

APP'(app'(app'(app'(filter2, true), f), x), xs) → APP'(app'(filter, f), xs)
APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(f, x)
APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(app'(map, f), xs)
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(f, x)
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
APP'(app'(app'(app'(filter2, false), f), x), xs) → APP'(app'(filter, f), xs)

The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(f, x)
APP'(app'(map, f), app'(app'(cons, x), xs)) → APP'(app'(map, f), xs)
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(f, x)
APP'(app'(filter, f), app'(app'(cons, x), xs)) → APP'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)

The remaining pairs can at least be oriented weakly.

APP'(app'(app'(app'(filter2, true), f), x), xs) → APP'(app'(filter, f), xs)
APP'(app'(app'(app'(filter2, false), f), x), xs) → APP'(app'(filter, f), xs)

Used ordering: Combined order from the following AFS and order.
APP'(x1, x2) = APP'(x2)
app'(x1, x2) = app'(x1, x2)
filter2 = filter2
true = true
filter = filter
map = map
cons = cons
false = false
nil = nil
plus = plus
0 = 0
app = app
minus = minus
sum = sum
quot = quot
s = s

Recursive path order with status [2].
Quasi-Precedence:

filter2 > [APP'₁, filter] > app'₂ > sum
filter2 > cons > plus > app'₂ > sum
true > [APP'₁, filter] > app'₂ > sum
true > cons > plus > app'₂ > sum
map > [APP'₁, filter] > app'₂ > sum
map > nil > cons > plus > app'₂ > sum
false > [APP'₁, filter] > app'₂ > sum
0 > sum
app > cons > plus > app'₂ > sum
s > quot > minus > plus > app'₂ > sum

Status:

app'₂: multiset
map: multiset
APP'₁: [1]
app: multiset
0: multiset
s: multiset
minus: multiset
nil: multiset
cons: multiset
filter: multiset
true: multiset
false: multiset
plus: multiset
sum: multiset
filter2: multiset
quot: multiset

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ EdgeDeletionProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

APP'(app'(app'(app'(filter2, true), f), x), xs) → APP'(app'(filter, f), xs)
APP'(app'(app'(app'(filter2, false), f), x), xs) → APP'(app'(filter, f), xs)

The TRS R consists of the following rules:

app'(app'(minus, x), 0) → x
app'(app'(minus, app'(s, x)), app'(s, y)) → app'(app'(minus, x), y)
app'(app'(minus, app'(app'(minus, x), y)), z) → app'(app'(minus, x), app'(app'(plus, y), z))
app'(app'(quot, 0), app'(s, y)) → 0
app'(app'(quot, app'(s, x)), app'(s, y)) → app'(s, app'(app'(quot, app'(app'(minus, x), y)), app'(s, y)))
app'(app'(plus, 0), y) → y
app'(app'(plus, app'(s, x)), y) → app'(s, app'(app'(plus, x), y))
app'(app'(app, nil), k) → k
app'(app'(app, l), nil) → l
app'(app'(app, app'(app'(cons, x), l)), k) → app'(app'(cons, x), app'(app'(app, l), k))
app'(sum, app'(app'(cons, x), nil)) → app'(app'(cons, x), nil)
app'(sum, app'(app'(cons, x), app'(app'(cons, y), l))) → app'(sum, app'(app'(cons, app'(app'(plus, x), y)), l))
app'(sum, app'(app'(app, l), app'(app'(cons, x), app'(app'(cons, y), k)))) → app'(sum, app'(app'(app, l), app'(sum, app'(app'(cons, x), app'(app'(cons, y), k)))))
app'(app'(map, f), nil) → nil
app'(app'(map, f), app'(app'(cons, x), xs)) → app'(app'(cons, app'(f, x)), app'(app'(map, f), xs))
app'(app'(filter, f), nil) → nil
app'(app'(filter, f), app'(app'(cons, x), xs)) → app'(app'(app'(app'(filter2, app'(f, x)), f), x), xs)
app'(app'(app'(app'(filter2, true), f), x), xs) → app'(app'(cons, x), app'(app'(filter, f), xs))
app'(app'(app'(app'(filter2, false), f), x), xs) → app'(app'(filter, f), xs)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 0 SCCs with 2 less nodes.